
package DB;

import Data.*;

import java.sql.PreparedStatement;
import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Date;
import java.util.Vector;

/**
 * Mapper Klasse, die Aircraft Objekte auf eine relationale DB abbildet.
 * Diese Klasse erlaubt zahlreiche Operationen, um ein Aircraft zu verwalten, z.B. eine LöschOperation oder eine EinfügeOperation
 * @author Stefan Fellner
 */
public class AircraftMapper {

    /*
     * Um sicher zu stellen, dass nur eine Instanz von der Klasse erzeugt wird, wird die Singleton Pattern angewendet.
     * Dies wird durch das Schlüsselwort static erreicht.
     * Quelle: http://www.theserverside.de/singleton-pattern-in-java/
     */
    private static AircraftMapper aircraftMapper = null;

    private ConnectionManager manager;

    /*mittels protected wird sichergestellt, dass mit new keine neuen Instanzen erstellt werden können.
     *Sobald ein Mapper Objekt erstellt wird, wird eine connection aufgebaut.*/

    protected AircraftMapper(){
        manager = ConnectionManager.getInstance();

    }

    /* Eine Instanz dieser Klasse sollte immer mittels der folgenden Methode erstellt werden.
     * Dadurch wird sicher gestellt, dass nur eine Instanz von dieser Klasse vorhanden ist.
     * @return DAS <code>AircraftMapper</code> Objekt
     * @see aircraftMapper
     */
    public static AircraftMapper getInstance(){

        if(aircraftMapper == null){
            aircraftMapper = new AircraftMapper();
        }

        return aircraftMapper;

    }


//Es folgen nun alle Methoden, die die Tabelle Aircraft verändern können, bzw. deren Inhalte abrufen können


    /* Ein Aircraft in die Datenbank einfügen.
     * @param das Aircraft Objekt welches hinzugefügt werden soll, die dazugehörende Airline und den Flugzeugtyp.
     * Es ist zu beachte, dass kein Aircraftnamen doppelt vorkommen darf. Ist dies der Fall, wird ein insert in die Datenbank verweigert und der User muss einen anderen Namen wählen.
     * @return das eingefügte Objekt.
     * Diese Methode wird den Primärschlüssel automatisch erzeugt. Der größte vorhandene Schlüssel wird um 1 erhöht.
     */
    public Aircraft insert (Aircraft craft){
        //DB verbindung vom Connection Manager Objekt holen
        Connection con = this.manager.getConnection();


        
        /*es wird sichergestellt, dass der Name der einzufügenden Aircraft noch nicht in der Datenbank vorhanden ist.*/
        try{
            if(findByName(craft.getCraftName()) != null){
                /*wenn schon ein Aircraft mit dem gleichen Namen existiert, wird null zurückgegeben und
                 *ie insert operation findet für das übergebene Objekt nicht statt.*/
               return null;
            }
        }
        catch(RemoteException ex){
            ex.printStackTrace();
        }




        try{
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            /*
             * Zunächst schauen wir nach, welches der momentan größte
             * Primärschlüsselwert eines Aircrafts ist.
             */
            ResultSet maxId = stmt.executeQuery("SELECT MAX(craftId) AS maxId " +"FROM aircraft");

            //die ergebnis Tabelle muss eine maxId zurückgeben.
            if(maxId.next()){
                try{

                 //Das einzufügende Objekt a erhält den neu errechneten Primärschlüssel
                 craft.setCraftId(maxId.getInt("maxId") + 1);

                    stmt = con.createStatement();

                     /**
                     * Jetzt erst erfolgt die tatsächliche Einfügeoperation.
                     * Die Attribute des Aircrafts, werden aus dem übergebenen Aircraft mit den getter Methoden geholt.
                      * Zudem werden die IDs von Airline und TypeOfAircraft geholt und abgespeichert.
                     * Diese sind Referenzen zu den dazugehörigen Datensätzen
                     */
                    stmt.executeUpdate("INSERT INTO aircraft (craftId, craftName, airId, craftTypeId) "+
                            "VALUES (" + "'"+
                            craft.getCraftId()+"'"+", "+"'"+
                            craft.getCraftName()+"'"+", "+"'"+
                            craft.getAirlineId()+"'"+", "+"'"+
                            craft.getTypeOfAircraftId()+"'"+")");
                }
                catch(RemoteException ex){
                    ex.printStackTrace();
                }
            }

        }
        //falls die SQL-Abfrage fehlschlägt...
        catch (SQLException e2) {
            e2.printStackTrace();
        }
        /*dieses return ist notwendig, da sich die ID des Aircrafts im Laufe der Methode
         *verändert und deswegen das ganze Objekt wieder zurückgegeben wird.*/
        return craft;
    }







    /* Ein Aircraft updaten, d.h. die Attribute des Aircrafts aktualisieren.
     * Dabei kann ein neuer Aircraft name gesetzt werden, eine neue Airline oder neuer Flugzeugtyp gesetzt werden.
     * Bei Airlne und TypeOfAircraft handelt es sich um die IDs
     * @param das Aircraft Objekt mit den aktualisierten Parametern.
     * @return Aircraft Objekt, welches in die Datenbank eingefügt wurde.
     */

     public Aircraft update (Aircraft craft){

         //DB verbindung vom Connection Manager Objekt holen
        Connection con = this.manager.getConnection();


        try{
                //sql statement
            PreparedStatement stmt = con.prepareStatement("UPDATE aircraft "+
                    "SET craftName= "+"'"+craft.getCraftName()+"'"+", "+
                    "airId= "+"'"+craft.getAirlineId()+"'"+", "+
                    "craftTypeId= "+"'"+craft.getTypeOfAircraftId()+"'"+
                    " WHERE craftId = "+"'"+craft.getCraftId()+"'");
            //dieser integer beinhaltet die Anzahl der veränderten Datensätze nach einer bestimmten UPDATE operation.
            int anzahlVeraenderterDatensaetze = stmt.executeUpdate();
            }
            //falls der Zugriff auf die Klassen Aircraft, Airline oder TypeOfAircraft scheitert.
            catch(RemoteException ex){
                ex.printStackTrace();
            }

        //falls die sql abfrage fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
        }
        //Dadurch wird sichergestellt, dass das Aircraft erfolgreich upgedatet wurde. Da bei Fehlern die Rückgabe NULL erfolgt, z.B. bei doppeltem AircraftNamen.
        return craft;

     }


     /*Ein bestimmtes Aircraft in der Datenbank löschen
      * @param die zu löschendes Aircraft
      */
     public void delete (Aircraft craft){

        //DB-Verbindung vom Connection Manager holen
        Connection con = this.manager.getConnection();

        try {
            // Leeres SQL-Statement anlegen
            Statement stmt = con.createStatement();

            stmt.executeUpdate("DELETE FROM aircraft "+
                               "WHERE craftId = "+"'"+craft.getCraftId()+"'");
        }
        //falls der Zugriff auf die Klasse Aircraft fehlschlägt.
        catch (RemoteException ex){
            ex.printStackTrace();
        }
        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
        }

     }

     /*Alle Aircrafts, die in der Tabelle vorhanden sind werden zurückgegeben.
      *Zudem werden die IDs der zugeordneten Airline und des TypeOfAircrafts gesetzt.
      *@return Vector mit allen Aircrafts
      */
     public Vector<Aircraft> findAll(){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Aircrafts Objekte festhalten wird, die in der Tabelle aircraft stehen
         Vector<Aircraft> allAircrafts = new Vector<Aircraft>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der Abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert.
             ResultSet allAircraftsQueryResult = stmt.executeQuery("SELECT craftId, craftName, airId, craftTypeId FROM aircraft "+"ORDER BY craftId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues Aircraft Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allAircraftsQueryResult.next()){
                 //ein neues Aircraft Objekt anlegen, welches in den Ergebnisvektor aufgenommen wird
                 Aircraft craft = new AircraftImpl(allAircraftsQueryResult.getString("craftName"), allAircraftsQueryResult.getInt("airId"), allAircraftsQueryResult.getInt("craftTypeId"));
                 //der Aircraft Konstruktor lässt das Setzen der ID nicht zu, deswegen wird die ID über die setter nachträglich gesetzt.
                 craft.setCraftId(allAircraftsQueryResult.getInt("craftId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allAircrafts.addElement(craft);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
             return null;
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
             return null;
         }
         //der Vector mit allen Aircrafts aus der Tabelle wird zurückgegeben
         return allAircrafts;
     }

     /* Aircrafts mit einem bestimmten Namen zurück geben. Es wird nur ein Aircraft zurückgegeben, da nur ein Aircraft mit diesem Namen existiert.
      * Zudem werden die IDs der Airline und des TypeOfAircrafts gesetzt.
      * @param den aircraftNamen
      * @return Aicraft Objekt, dass dem übergebenen Namen entspricht.
      */

     public Aircraft findByName(String craftName){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();

         try{

             Statement stmt = con.createStatement();

             ResultSet desiredAircraft = stmt.executeQuery("SELECT craftId, craftName, airId, craftTypeId FROM aircraft "+
                                                         "WHERE craftName = "+"'"+craftName+"'");

             //prüfen, ob es ein Aircraft mit dem übergebenen Namen gibt
             if(desiredAircraft.next()){
                 //ein neues Aircraft Objekt anlegen
                 Aircraft craft = new AircraftImpl(desiredAircraft.getString("craftName"), desiredAircraft.getInt("airId"), desiredAircraft.getInt("craftTypeId"));
                 //da der konstruktor das setzen der ID nicht zulässt, wird die ID über eine setter Methode gesetzt.
                 craft.setCraftId(desiredAircraft.getInt("craftId"));
                 //das gerade erstellte Objekt wird zurückgegeben
                 return craft;

            }

         }
         //falls der Zugriff auf die Klasse Aircraft fehlschlägt
        catch (RemoteException ex){
            ex.printStackTrace();
            return null;
        }
        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
            return null;
        }
        //falls kein aircraft in der DB vorhanden ist und es keine Fehlermeldung gab, wird NULL zurückgegeben
         return null;
     }



     /*Ein bestimmtes Aircraft abhängig von der ID finden.
      *
      * @param die AircraftID als integer
      * @return das gesuchte Aircraft Objekt
      */

     public Aircraft findById(int craftId){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();

         try{

             Statement stmt = con.createStatement();

             ResultSet desiredAircraft = stmt.executeQuery("SELECT craftId, craftName, airId, craftTypeId FROM aircraft "+
                                                           "WHERE craftId = "+"'"+craftId+"'");

             //es gibt nur ein Aircraft mit gleicher ID. Es wird zunächst geschaut ob, ein Aircraft in der ResultSet "Tabelle" ist
             if(desiredAircraft.next()){
                 //den ergebnisDatensatz in ein Objekt umwandeln
                 Aircraft craft = new AircraftImpl(desiredAircraft.getString("craftName"), desiredAircraft.getInt("airId"), desiredAircraft.getInt("craftTypeId"));
                 craft.setCraftId(desiredAircraft.getInt("craftId"));
                 //das gefundene aircraft Objekt zurückgeben
                 return craft;
             }

         }
         //falls der Zugriff auf die Klasse Aircraft fehlschlägt
        catch (RemoteException ex){
            ex.printStackTrace();
            return null;
        }
        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
            return null;
        }
        //wenn kein Aircraft gefunden wurde und keine Fehlermeldung ausgegeben wurde, gibt die Methode null zurück.
         return null;
     }


     

     /* Alle Aircrafts, die den übergebenen type bzw. dessen ID als Fremdschlüssel Attribut haben, werden gelöscht.
      * Diese Methode wird im Zuge einer Löschung von TypeOfAircrafts von der Verwaltung aufgerufen
      * @param der TypeOfAircraft der gelöscht wird
      */
     public void deleteAllAircraftsWithTypeOfAircraftId(int typeOfAircraftId){
         //DB-Verbindung vom Connection Manager holen
        Connection con = this.manager.getConnection();

        try {
            // Leeres SQL-Statement anlegen
            Statement stmt = con.createStatement();

            stmt.executeUpdate("DELETE FROM aircraft "+
                               "WHERE craftTypeId = "+"'"+typeOfAircraftId+"'");
        }
        
        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
        }
     }


     /* Alle Aircrafts, die den übergebenen type bzw. dessen ID als Fremdschlüssel Attribut haben, werden gelöscht.
      * Diese Methode wird im Zuge einer Löschung von TypeOfAircrafts von der Verwaltung aufgerufen
      * @param der TypeOfAircraft der gelöscht wird
      */
     public void deleteAllAircraftsWithAirlineId(int airlineId){
         //DB-Verbindung vom Connection Manager holen
        Connection con = this.manager.getConnection();

        try {
            // Leeres SQL-Statement anlegen
            Statement stmt = con.createStatement();

            stmt.executeUpdate("DELETE FROM aircraft "+
                               "WHERE airId = "+"'"+airlineId+"'");
        }

        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
        }
     }



     /*alle Aircrafts abhängig von der TypeOfAircraftId finden
      *
      * @param die ID des TypeOfAircrafts
      * @return alle passenden Einträge mit der übergebenen ID
      */

     public Vector<Aircraft> findByTypeOfAircraftId(int typeOfAircraftId){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Aircrafts Objekte festhalten wird, die in der Tabelle aircraft stehen
         Vector<Aircraft> allAircrafts = new Vector<Aircraft>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allAircraftsQueryResult = stmt.executeQuery("SELECT craftId, craftName, airId, craftTypeId FROM aircraft "+"WHERE craftTypeId = "+"'"+typeOfAircraftId+"'"+"ORDER BY craftId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues Aircraft Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allAircraftsQueryResult.next()){
                 //ein neues Aircraft Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Aircraft craft = new AircraftImpl(allAircraftsQueryResult.getString("craftName"), allAircraftsQueryResult.getInt("airId"), allAircraftsQueryResult.getInt("craftTypeId"));
                 //der Aircraft kkonstruktor lässt das setzen der ID nicht zu, deswegen wird die ID über die setter nachträglich gesetzt.
                 craft.setCraftId(allAircraftsQueryResult.getInt("craftId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allAircrafts.addElement(craft);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
             return null;
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
             return null;
         }
         //der vector mit allen aircrafts aus der Tabelle wird zurückgegeben
         return allAircrafts;
     }


     /*Alle Aircrafts abhängig von der AirlineId finden
      *
      * @param die ID der Airline
      * @return alle passenden Einträge mit der übergebenen ID
      */

     public Vector<Aircraft> findByAirlineId(int airlineId){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Aircrafts Objekte festhalten wird, die in der Tabelle aircraft stehen
         Vector<Aircraft> allAircrafts = new Vector<Aircraft>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allAircraftsQueryResult = stmt.executeQuery("SELECT craftId, craftName, airId, craftTypeId FROM aircraft "+"WHERE airId = "+"'"+airlineId+"'"+"ORDER BY craftId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues Aircraft Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allAircraftsQueryResult.next()){
                 //ein neues Aircraft Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Aircraft craft = new AircraftImpl(allAircraftsQueryResult.getString("craftName"), allAircraftsQueryResult.getInt("airId"), allAircraftsQueryResult.getInt("craftTypeId"));
                 //der Aircraft kkonstruktor lässt das setzen der ID nicht zu, deswegen wird die ID über die setter nachträglich gesetzt.
                 craft.setCraftId(allAircraftsQueryResult.getInt("craftId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allAircrafts.addElement(craft);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
             return null;
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
             return null;
         }
         //der vector mit allen aircrafts aus der Tabelle wird zurückgegeben
         return allAircrafts;
     }



     /**
	 * Auslesen des zugehörigen <code>Airline</code>-Objekts zu einem gegebenen
	 * Aircraft.
	 *
	 * @param das Aircraft, wessen Airline erfahren werden soll.
	 * @return ein Objekt, welches die gesuchte Airline darstellt
	 */
	public Airline getAirlineOfAircraft(Aircraft craft) {
		try {
			/*
			 * Die AirlineMapper Klasse wird aufgerufen bzw. deren findById Methode.
                         * Dadurch bekommen wir das gesuchte Airline Objekt zurück
			 */
                         return AirlineMapper.getInstance().findById(craft.getAirlineId());
			
		}
		catch (RemoteException e) {
			e.printStackTrace();
			// Wenn der Zugriff auf die AirlineMapper fehlschlägt, dann geben wir null zurück.
			return null;
		}
	}

        /**
	 * Auslesen des zugehörigen <code>TypeOfAircraft</code>-Objekts zu einem gegebenen
	 * Aircraft.
	 *
	 * @param das AircraftObjekt, wessen Type erfahren werden soll.
	 * @return ein Objekt, welches den gesuchten TypeOfAircraft darstellt
	 */
	public TypeOfAircraft getTypeOfAircraftOfAircraft(Aircraft craft) {
		try {
			/*
			 * Die TypeOfAircraftMapper Klasse wird aufgerufen bzw. deren findById Methode.
                         * Dadurch bekommen wir das gesuchte TypeOfAircraft Objekt zurück
			 */
                         return TypeOfAircraftMapper.getInstance().findById(craft.getTypeOfAircraftId());

		}
		catch (RemoteException e) {
			e.printStackTrace();
			// Wenn der Zugriff auf die TypeOfAircraftMapper fehlschlägt, dann geben wir null zurück.
			return null;
		}
	}

     /*Alle Aircrafts, die an den übergebenen Tagen,
      *von der übergebenen Airline nicht einer FlightRealization zugeordnet sind, werden zurückgegeben.
      *@param dateOfDeparture, dateOfArrival
      *@return Vector mit allen verfügbaren Aircrafts
      */
     public Vector<Aircraft> findAircraftsByAvailability(Date dateOfDeparture, Date dateOfArrival, int airlineId){

            //date Objekte in sql dates umwandeln
            java.sql.Date departureDate = utilDateToSqlDate(dateOfDeparture);
            java.sql.Date arrivalDate = utilDateToSqlDate(dateOfArrival);

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Aircrafts Objekte festhalten wird, die von der übergebenen Airline sind.
         Vector<Integer> allAircraftsFromAirline = new Vector<Integer>();
         //Vector, der alle Aircraft IDs festhalten wird, die an den übergebenen Tagen nicht verwendet werden.
         Vector<Integer> allAircraftsAvailableOnDates = new Vector<Integer>();
         //Vector, der von beiden oben erstelleten Vektoren die Schnittmenge festhält
         Vector<Integer> bothCriteria = new Vector<Integer>();
         //Vector, der alle zu dem übergebenen Zeitraum verfügbaren Aircrafts beinhaltet.
         Vector<Aircraft> allAvailableAircrafts = new Vector<Aircraft>();

         try{
         //zunächst werden alle aircrafts mit der übergebenen airline id geholt und abgespeichert.
             Statement stmt = con.createStatement();
             ResultSet allAircraftsQueryResult = stmt.executeQuery("SELECT craftId FROM aircraft "+
                                                                   "WHERE airId = "+"'"+airlineId+"'");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues Aircraft Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allAircraftsQueryResult.next()){

                 int currentAircraftId = allAircraftsQueryResult.getInt("craftId");

                 Integer integer = new Integer(currentAircraftId);

                 allAircraftsFromAirline.add(integer);

             }
             

             //nun werden alle Aircrafts, die an den beiden Daten verwendet werden in einen vector gespeichert.

             Statement stmt2 = con.createStatement();
             ResultSet allAircraftsTimeframeQueryResult = stmt2.executeQuery("SELECT * FROM flightRealization "+
                                                                           "WHERE ((dateOfDeparture = "+"'"+departureDate+"'"+" OR dateOfArrival = "+"'"+arrivalDate+"') OR "+
                                                                           "(dateOfDeparture = "+"'"+arrivalDate+"'"+" OR dateOfArrival = "+"'"+departureDate+"'))");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neuer integer erstellt und zum ergebnisVector hinzugefügt.
             while(allAircraftsTimeframeQueryResult.next()){

                 int currentAircraftId = allAircraftsTimeframeQueryResult.getInt("craftId");

                 Integer integer = new Integer(currentAircraftId);

                 allAircraftsAvailableOnDates.add(integer);

             }
             


             //die oben erstellten Integer Vectoren müssen jetzt abgeglichen werden. Jede ID die in beiden Vectoren vorkommt, wird in den temporären Ergebnisvektor gespeichert.

             for(int i=0; i<allAircraftsFromAirline.size();i++){

                 if(allAircraftsAvailableOnDates.contains(allAircraftsFromAirline.get(i))){

                     //es wird nichts gemacht, da alle flugzeuge, die in dem allAircraftsAvailableOnDates vector beinhaltet sind, nicht verfügbar sind
                 }
                 else{
                     bothCriteria.add(allAircraftsFromAirline.get(i));
                 }
             }
             

             

             //jetzt erst wird der endgültige ergebnisvektor erstellt.
             for(int i=0; i<bothCriteria.size(); i++){

             //zunächst werden alle aircrafts mit der übergebenen airline id geholt und abgespeichert.
             Statement stmt3 = con.createStatement();
             ResultSet allAvailableAircraftsQueryResult = stmt3.executeQuery("SELECT craftId, craftName, airId, craftTypeId FROM aircraft "+
                                                         "WHERE craftId = "+"'"+bothCriteria.get(i).hashCode()+"'");

                 //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neuer integer erstellt und zum ergebnisVector hinzugefügt.
                 while(allAvailableAircraftsQueryResult.next()){

                 //ein neues Aircraft Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                     Aircraft craft = new AircraftImpl(allAvailableAircraftsQueryResult.getString("craftName"), allAvailableAircraftsQueryResult.getInt("airId"), allAvailableAircraftsQueryResult.getInt("craftTypeId"));
                     //der Aircraft kkonstruktor lässt das setzen der ID nicht zu, deswegen wird die ID über die setter nachträglich gesetzt.
                     craft.setCraftId(allAvailableAircraftsQueryResult.getInt("craftId"));

                     //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                     allAvailableAircrafts.addElement(craft);

                 }
             }

             //return allAvailableAircrafts;
             return allAvailableAircrafts;



         }
         catch(RemoteException ex){
             ex.printStackTrace();
             return null;
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
             return null;
         }

     }





         /*Quelle: http://blog.mynotiz.de/programmieren/mysql-timestamp-in-java-date-umwandeln-und-umgekehrt-285/*/
    public Date sqlDateToUtilDate(java.sql.Date sqlDate){

         if(sqlDate == null){
             java.sql.Date nullWerte = new java.sql.Date(0);
             Date dateNullWerte = new Date(nullWerte.getTime());
             return dateNullWerte;
         }
        else{
            Date date = new Date(sqlDate.getTime());
            return date;
         }
  }


    /*helfer Methode für die Umwandlung von java.util.Date in sql.Date
     *Quelle: http://blog.mynotiz.de/programmieren/mysql-timestamp-in-java-date-umwandeln-und-umgekehrt-285/*/
    public java.sql.Date utilDateToSqlDate(Date date){

        java.sql.Date sqlDate = new java.sql.Date(date.getTime());
        return sqlDate;
  }



}

